package com.ea.modular.utils.sys;


import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;


import com.ea.common.Constants.UserConstants;
import com.ea.common.node.MenuNode;
import com.ea.common.node.ZTreeNode;
import com.ea.common.utils.CacheUtils;
import com.ea.common.utils.ToolUtil;
import com.ea.modular.dao.sys.MenuDao;
import com.ea.modular.dao.sys.OfficeDao;
import com.ea.modular.dao.sys.RoleDao;
import com.ea.modular.dao.sys.UserDao;
import com.ea.modular.model.sys.Menu;
import com.ea.modular.model.sys.Office;
import com.ea.modular.model.sys.Role;
import com.ea.modular.model.sys.ShiroUser;
import com.ea.modular.model.sys.User;






public class UserUtil {

	private static MenuDao menuDao=SpringUtil.getBean(MenuDao.class);
	private static RoleDao roleDao=SpringUtil.getBean(RoleDao.class);
    private static UserDao userDao=SpringUtil.getBean(UserDao.class);
    private static OfficeDao officeDao=SpringUtil.getBean(OfficeDao.class);
	/**
	 * 已认证通过的用户。不包含已记住的用户，这是与user标签的区别所在。与notAuthenticated搭配使用
	 *
	 * @return 通过身份验证：true，否则false
	 */
	public static boolean isAuthenticated() {
		return getSubject() != null && getSubject().isAuthenticated();
	}
	/**
	 * 获取当前 Subject
	 *
	 * @return Subject
	 */
	public static Subject getSubject() {
		return SecurityUtils.getSubject();
	}


	/**
	 * 获取封装的 用户
	 *
	 * @return user
	 */
	public static ShiroUser getCurrentUser() {
		return (ShiroUser) getSession().getAttribute(UserConstants.LOGIN_USER);
	}

	/**
	 * 从shiro获取session
	 *
	 */
	public static Session getSession() {
		Subject currentUser = SecurityUtils.getSubject();

		Session session = currentUser.getSession();

		return session;
	}
	/**
	 * 设置session
	 * @param user
	 */
	public static void setUserSession(ShiroUser shiroUser) {
		getSession().setAttribute(UserConstants.LOGIN_USER, shiroUser);
	}




	/**
	 * 验证当前用户是否拥有指定权限,使用时与lacksPermission 搭配使用
	 *
	 * @param permission 权限名
	 * @return 拥有权限：true，否则false
	 */
	public static boolean hasPermission(String permission) {
		return getSubject() != null && permission != null
				&& permission.length() > 0
				&&getSubject().isPermitted(permission);
	}

	/**
	 * 与hasPermission标签逻辑相反，当前用户没有制定权限时，验证通过。
	 *
	 * @param permission 权限名
	 * @return 拥有权限：true，否则false
	 */
	public boolean lacksPermission(String permission) {
		return !hasPermission(permission);
	}






	//////////////////////获取系统的基础信息//////////////////////////

	/**
	 * 获得登录用户所拥有的所有缓存菜单
	 * @param roleIds
	 * @return
	 */
	public static List<MenuNode> getMenusByRoleIds(List<String> roleIds) {
		@SuppressWarnings("unchecked")
		List<MenuNode> list=(List<MenuNode>)CacheUtils.get(UserConstants.LOGIN_MENUS);
		if(ToolUtil.isEmpty(list)) {
			list=menuDao.getMenusByRoleIds(roleIds);
			CacheUtils.put(UserConstants.LOGIN_MENUS, list);
		}
		return list;
	}

	/**
	 * 获得菜单编辑时所拥有的菜单
	 * @return
	 */
	public static List<ZTreeNode> getMenutree() {
		@SuppressWarnings("unchecked")
		List<ZTreeNode> list=(List<ZTreeNode>)CacheUtils.get(UserConstants.MENU_EDIT);
		if(ToolUtil.isEmpty(list)) {
			list=menuDao.tree();
			CacheUtils.put(UserConstants.MENU_EDIT, list);
		}
		return list;
	}
	
	/**
	 * 获取菜单页的所有菜单缓存
	 * @param name
	 * @return
	 */
	public static List<Menu> getMenus(String name){
		@SuppressWarnings("unchecked")
		List<Menu> list=(List<Menu>)CacheUtils.get(UserConstants.MENUS_ADMIN);
		if(ToolUtil.isEmpty(list)) {
			list=menuDao.findList(new Menu());
			CacheUtils.put(UserConstants.MENUS_ADMIN, list);
		}
        //如果查询参数不为空
		if(ToolUtil.isNotEmpty(name)) {
			List<Menu> lt=new ArrayList<Menu>();
			for (Menu menu : list) {
				if(menu.getName().contains(name)) {
					lt.add(menu);
				}
			}
			return lt;
		}
		
		return list;
	}
	
	/**
	 * 获取菜单所关联的所有的权限
	 * @param roleIds
	 * @return
	 */
	public static Set<String> getPermissionByRoleIds(List<String> roleIds){
		@SuppressWarnings("unchecked")
		Set<String> list=(Set<String>)CacheUtils.get(UserConstants.USER_PERMISSIONS);
		if(ToolUtil.isEmpty(list)) {
			list=menuDao.getPermissionByRoleIds(roleIds);
			CacheUtils.put(UserConstants.USER_PERMISSIONS, list);
		}
		return list;
	}
	
	/**
	 * 根据菜单ID来获取菜单
	 * @param menuId
	 * @return
	 */
	public static Menu getMenuById(String menuId) {
		List<Menu> menus=getMenus("");
		for (Menu m : menus) {
			if(m.getId().equals(menuId)) {
				return m;
			}
		}
		return null;
	}
	
	
	/**
	 * 清除菜单地方的缓存
	 */
	public static void clearMenuCache() {
		//清除菜单页的所有菜单缓存
		CacheUtils.remove(UserConstants.MENUS_ADMIN);
		//清除菜单页的所有菜单缓存
		CacheUtils.remove(UserConstants.MENU_EDIT);
		//清除登录地方的菜单缓存
		CacheUtils.remove(UserConstants.LOGIN_MENUS);
		//清除菜单所关联的所有的权限
		CacheUtils.remove(UserConstants.USER_PERMISSIONS);
		
	}
	
	
	/**
	 * 获取当前用户所关联的角色名缓存
	 * @param roleIds
	 * @return
	 */
	public static Set<String> getRoleNames(List<String> roleIds){
		@SuppressWarnings("unchecked")
		Set<String> list=(Set<String>)CacheUtils.get(UserConstants.ROLE_NAMES);
		if(ToolUtil.isEmpty(list)) {
			list=roleDao.getRoleNames(roleIds);
			CacheUtils.put(UserConstants.ROLE_NAMES, list);
		}
		return list;
	}
	/**
	 * 获取当前用户所关联的角色ID缓存
	 * @param roleIds
	 * @return
	 */
	public static List<String> getRoleIDS(String userId){
		@SuppressWarnings("unchecked")
		List<String> list=(List<String>)CacheUtils.get(UserConstants.ROLE_IDS);
		if(ToolUtil.isEmpty(list)) {
			list=roleDao.getRoleIds(userId);
			CacheUtils.put(UserConstants.ROLE_IDS, list);
		}
		return list;
	}
	
	
	
	/**
	 * 获取角色列表
	 * @return
	 */
	public static List<Role> getRoles(){
		@SuppressWarnings("unchecked")
		List<Role> list=(List<Role>)CacheUtils.get(UserConstants.ROLE_LIST);
		if(ToolUtil.isEmpty(list)) {
			list=roleDao.findAllList(new Role());
			CacheUtils.put(UserConstants.ROLE_LIST, list);
		}
		return list;
	}
	
	/**
	 * 根据角色ID得到缓存的角色
	 * @param id
	 * @return
	 */
	public static Role getRoleById(String id) {
		List<Role> roles = getRoles();
		for (Role role : roles) {
			if(role.getId().equals(id)) {
				return role;
			}
		}
		return null;
	}

	/**
	 * 根据角色名称得到缓存的角色
	 * @param id
	 * @return
	 */
	public static Role getRoleByName(String name) {
		List<Role> roles = getRoles();
		for (Role role : roles) {
			if(role.getName().equals(name)) {
				return role;
			}
		}
		return null;
	}
	
	
	
	
	/**
	 * 清除角色地方的缓存
	 */
	public static void clearRoleCache() {
		//清除当前用户所关联的角色ID缓存
		CacheUtils.remove(UserConstants.ROLE_IDS);
		//清除当前用户所关联的角色名缓存
		CacheUtils.remove(UserConstants.ROLE_NAMES);
		//清除角色列表
		CacheUtils.remove(UserConstants.ROLE_LIST);		
	}
	
	/**
	 * 清除用户列表
	 */
	public static void clearUserCache(){
		//清除用户列表
		CacheUtils.remove(UserConstants.USER_LIST);
	}
	
	/**
	 * 缓存用户列表
	 * @return
	 */
	public static List<User> getUsers(){
		@SuppressWarnings("unchecked")
		List<User> list=(List<User>)CacheUtils.get(UserConstants.USER_LIST);
		if(ToolUtil.isEmpty(list)) {
			list=userDao.findAllList(new User());
			CacheUtils.put(UserConstants.USER_LIST, list);
		}
		return list;
	}
	/**
	 * 根据用户ID得到缓存的用户
	 * @param id
	 * @return
	 */
	public static User getUserById(String id) {
		
		List<User> list=getUsers();
		
		for (User user : list) {
			if(user.getId().equals(id)) {
				return user;
			}
		}
		return null;
	}

	/**
	 * 根据登录名来获取用户
	 * @param loginName
	 * @return
	 */
	public static User getUserByLoginName(String loginName) {
		List<User> users = getUsers();
		for (User user : users) {
			if(user.getLoginName().equals(loginName)) {
				return user;
			}
		}
		return null;
	}

	/**
	 * 根据工号来获取用户
	 * @param no
	 * @return
	 */
	public static User getUserByNo(String no) {
		List<User> users = getUsers();
		for (User user : users) {
			if(user.getNo().equals(no)) {
				return user;
			}
		}
		return null;
	}

	
	
	/**
	 * 获取机构页的所有缓存
	 * @param name
	 * @return
	 */
	public static List<Office> getOffices(String name){
		@SuppressWarnings("unchecked")
		List<Office> list=(List<Office>)CacheUtils.get(UserConstants.OFFICE_LIST);
		if(ToolUtil.isEmpty(list)) {
			list=officeDao.findList(new Office());
			CacheUtils.put(UserConstants.OFFICE_LIST, list);
		}
        //如果查询参数不为空
		if(ToolUtil.isNotEmpty(name)) {
			List<Office> lt=new ArrayList<Office>();
			for (Office o : list) {
				if(o.getName().contains(name)) {
					lt.add(o);
				}
			}
			return lt;
		}
		
		return list;
	}
	
	

	/**
	 * 根据机构ID来获取机构
	 * @param officeId
	 * @return
	 */
	public static Office getOfficeById(String officeId) {
		List<Office> offices=getOffices("");
		for (Office off : offices) {
			if(off.getId().equals(officeId)) {
				return off;
			}
		}
		return null;
	}
	
	/**
	 * 获得机构编辑时所拥有机构
	 * @return
	 */
	public static List<ZTreeNode> getOfficetree() {
		@SuppressWarnings("unchecked")
		List<ZTreeNode> list=(List<ZTreeNode>)CacheUtils.get(UserConstants.OFFICE_EDIT);
		if(ToolUtil.isEmpty(list)) {
			list=officeDao.tree();
			CacheUtils.put(UserConstants.OFFICE_EDIT, list);
		}
		return list;
	}
	
	
	/**
	 * 获得机构外部树
	 * @return
	 */
	public static List<ZTreeNode> getOfficeOuttree() {
		@SuppressWarnings("unchecked")
		List<ZTreeNode> list=(List<ZTreeNode>)CacheUtils.get(UserConstants.OFFICE_OUT);
		if(ToolUtil.isEmpty(list)) {
			list=officeDao.outtree();
			CacheUtils.put(UserConstants.OFFICE_OUT, list);
		}
		return list;
	}
	
	/**
	 * 清除机构部份缓存
	 */
	public static void clearOfficeCache() {
		//清除机构内部树
		CacheUtils.remove(UserConstants.OFFICE_EDIT);
		//清除机构外部树
		CacheUtils.remove(UserConstants.OFFICE_OUT);
		//清除机构列表
		CacheUtils.remove(UserConstants.OFFICE_LIST);
	}
	
	/**
	 * 清除所有的缓存信息
	 */
	public static void clearAllCache() {
		CacheUtils.removeAll("sysCache");
	}
	

}
